package com.ruoyi.bus.service.impl;

import com.ruoyi.bus.domain.BusData;
import com.ruoyi.bus.domain.BusMonitor;
import com.ruoyi.bus.domain.MonitorDataBo;
import com.ruoyi.bus.dto.BusDataResult;
import com.ruoyi.bus.mapper.BusDataAuditMapper;
import com.ruoyi.bus.mapper.BusDataMapper;
import com.ruoyi.bus.mapper.BusMonitorMapper;
import com.ruoyi.bus.service.IBusDataService;
import com.ruoyi.common.config.MonitorDataProperties;
import com.ruoyi.common.core.text.Convert;
import com.ruoyi.common.enums.PollutionFactorEnum;
import com.ruoyi.common.utils.DateUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.web.client.RestTemplate;

import java.lang.reflect.Field;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 【请填写功能名称】Service业务层处理
 * 
 * @author ruoyi
 * @date 2021-08-31
 */
@Service
public class BusDataServiceImpl implements IBusDataService 
{
    private static final Logger log = LoggerFactory.getLogger(BusDataServiceImpl.class);

    @Autowired
    private BusDataMapper busDataMapper;

    @Autowired
    private BusDataAuditMapper busDataAuditMapper;

    @Autowired
    MonitorDataProperties monitorDataProperties;

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private BusMonitorMapper busMonitorMapper;

    /**
     * 查询【请填写功能名称】
     * 
     * @param collectId 【请填写功能名称】主键
     * @return 【请填写功能名称】
     */
    @Override
    public BusData selectBusDataByCollectId(Long collectId)
    {
        return busDataMapper.selectBusDataByCollectId(collectId);
    }

    @Override
    public List<BusData> selectMonitorName(BusData busData) {
        return busDataMapper.selectMonitorName(busData);
    }

    @Override
    public List<BusData> selectBusDataMonth(BusData busData) {
        return busDataMapper.selectBusDataMonth(busData);
    }

    @Override
    public List<BusData> selectBusDataDay(BusData busData) {
        return busDataMapper.selectBusDataDay(busData);
    }

    @Override
    public List<BusDataResult> selectAlert(Long monitorId) {
        return busDataMapper.selectAlert(monitorId);
    }


    /**
     * 查询【请填写功能名称】
     *
     * @param monitorId 【请填写功能名称】主键
     * @return 【请填写功能名称】
     */
    @Override
    public BusData selectBusDataByMonitorId(Long monitorId) {
        List<BusData> list = busDataMapper.selectBusDataByMonitorId(monitorId);

        if (null !=list && list.size()>0) {
            return list.get(0);
        }
        return null;
    }


    /**
     * 查询【请填写功能名称】
     *
     * @param monitorId 【请填写功能名称】
     * @param produceTime 【请填写功能名称】
     * @return 【请填写功能名称】
     */
    @Override
    public List<BusData> selectBusDataByDay(Long monitorId, String produceTime) {
        return busDataMapper.selectBusDataByDay(monitorId,produceTime);
    }


    /**
     * 查询【请填写功能名称】列表
     * 
     * @param busData 【请填写功能名称】
     * @return 【请填写功能名称】
     */
    @Override
    public List<BusDataResult> selectBusDataList(BusData busData)
    {
        return busDataMapper.selectBusDataList(busData);
    }

    /**
     * 查询【请填写功能名称】列表
     *
     * @param busData 【请填写功能名称】
     * @return 【请填写功能名称】
     */
    @Override
    public List<BusDataResult> selectBusDataListMn(BusData busData)
    {
        return busDataMapper.selectBusDataListMn(busData);
    }


    /**
     * 新增【请填写功能名称】
     * 
     * @param busData 【请填写功能名称】
     * @return 结果
     */
    @Override
    public int insertBusData(BusData busData)
    {
        return busDataMapper.insertBusData(busData);
    }

    /**
     * 修改【请填写功能名称】
     * 
     * @param busData 【请填写功能名称】
     * @return 结果
     */
    @Override
    public int updateBusData(BusData busData)
    {
        return busDataMapper.updateBusData(busData);
    }

    /**
     * 批量删除【请填写功能名称】
     * 
     * @param collectIds 需要删除的【请填写功能名称】主键
     * @return 结果
     */
    @Override
    public int deleteBusDataByCollectIds(String collectIds)
    {
        return busDataMapper.deleteBusDataByCollectIds(Convert.toStrArray(collectIds));
    }

    /**
     * 删除【请填写功能名称】信息
     * 
     * @param collectId 【请填写功能名称】主键
     * @return 结果
     */
    @Override
    public int deleteBusDataByCollectId(Long collectId)
    {
        return busDataMapper.deleteBusDataByCollectId(collectId);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void pullMonitorData2Db() {
        List<BusMonitor> busMonitors =  busMonitorMapper.selectBusMonitorList(new BusMonitor());
        //查找sid数据
        for (BusMonitor obj :busMonitors) {
            if (StringUtils.isBlank(obj.getMnCode())) {
                continue;
            }
            StringBuilder str = new StringBuilder(monitorDataProperties.getRequestUrl());
            str.append("?client=").append(monitorDataProperties.getClient()).append("&stationID=").append(obj.getMnCode())
                    .append("&startTime=").append(DateUtils.getBeforeDay(-14));
            MonitorDataBo bo = restTemplate.getForObject(str.toString(), MonitorDataBo.class);
            //验参
            if (CollectionUtils.isEmpty(bo.getDatas())) {
                log.error("BusDataService pullMonitorData2Db 参数为空！");
                continue;
            }
            //按时间分组打包；遍历映射实体
            Map<String, List<MonitorDataBo.Data>> mapByTime = bo.getDatas().stream().filter(Objects::nonNull).collect(Collectors.groupingBy(MonitorDataBo.Data::getTime));
            for (Map.Entry<String, List<MonitorDataBo.Data>> entry : mapByTime.entrySet()) {
                BusData entity = new BusData();
                int flag = 0;
                List<MonitorDataBo.Data> mList = entry.getValue();
                for (MonitorDataBo.Data data : mList) {
                    try {
                        PollutionFactorEnum pollutionFactorEnum = PollutionFactorEnum.getByName(data.getFactor());
                        if (pollutionFactorEnum == null) {
                            continue;
                        }
                        if (StringUtils.isBlank(data.getResult()) || "''".equals(data.getResult())) {
                            continue;
                        }
                        flag++;
                        Field declaredField = entity.getClass().getDeclaredField(pollutionFactorEnum.getEntityField());
                        declaredField.setAccessible(true);
                        declaredField.set(entity, data.getResult());
                    } catch (Exception e) {
                        log.error("BusDataService pullMonitorData2Db 映射BusData实体失败！请检查PollutionFactorEnum枚举。");
                        e.printStackTrace();
                    }
                }
                if (flag == 0) {
                    //9个监测值都为空，跳过
                    continue;
                }
                entity.setMonitorId(obj.getMonitorId());
                entity.setProduceTime(entry.getKey());
                entity.setMonitorName(obj.getMonitorName());
//                List<String> notice = new ArrayList<>();
//                //取出阈值进行比较
//                List<BusDataAuditResult> list = busDataAuditMapper.getAuditData(obj.getMonitorId());
//                List<BusDataAuditResult> collect = list.stream().filter(e -> {
//                    for (MonitorDataBo.Data monitor : mList) {
//                        if (e.getFactorCode().equals(monitor.getFactor())
//                                && (Long.valueOf(monitor.getResult()) > Long.valueOf(e.getMaxValue())
//                                || Long.valueOf(monitor.getResult()) < Long.valueOf(e.getMinValue()))) {
//                            notice.add(PollutionFactorEnum.getByName(monitor.getFactor()).getEntityField());
//                            return false;
//                        }
//                    }
//                    return true;
//                }).collect(Collectors.toList());
//                if (!CollectionUtils.isEmpty(notice)) {
//                    entity.setNotice(String.join(",", notice));
//                }
                List<BusData> data = busDataMapper.selectBusDataListByTime(entity.getMonitorId(),entity.getProduceTime());
                if (CollectionUtils.isEmpty(data)) {
                    //插入数据库
                    busDataMapper.insertBusData(entity);
                } else {
                    BusData busObj = data.get(0);
                    entity.setCollectId(busObj.getCollectId());
                    busDataMapper.updateBusData(entity);
                }
            }
        }
    }
}
